home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gcc_260.zip / gcc_260 / genconfig.c < prev    next >
C/C++ Source or Header  |  1994-06-15  |  9KB  |  364 lines
  1. /* Generate from machine description:
  2.  
  3.    - some #define configuration flags.
  4.    Copyright (C) 1987, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU CC.
  7.  
  8. GNU CC is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 2, or (at your option)
  11. any later version.
  12.  
  13. GNU CC is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with GNU CC; see the file COPYING.  If not, write to
  20. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22.  
  23. #include <stdio.h>
  24. #include "hconfig.h"
  25. #include "rtl.h"
  26. #include "obstack.h"
  27.  
  28. static struct obstack obstack;
  29. struct obstack *rtl_obstack = &obstack;
  30.  
  31. #define obstack_chunk_alloc xmalloc
  32. #define obstack_chunk_free free
  33.  
  34. extern void free ();
  35. extern rtx read_rtx ();
  36.  
  37. /* flags to determine output of machine description dependent #define's.  */
  38. static int max_recog_operands;  /* Largest operand number seen.  */
  39. static int max_dup_operands;    /* Largest number of match_dup in any insn.  */
  40. static int max_clobbers_per_insn;
  41. static int register_constraint_flag;
  42. static int have_cc0_flag;
  43. static int have_cmove_flag;
  44. static int have_lo_sum_flag;
  45.  
  46. /* Maximum number of insns seen in a split.  */
  47. static int max_insns_per_split = 1;
  48.  
  49. static int clobbers_seen_this_insn;
  50. static int dup_operands_seen_this_insn;
  51.  
  52. char *xmalloc ();
  53. static void fatal ();
  54. void fancy_abort ();
  55.  
  56. /* RECOG_P will be non-zero if this pattern was seen in a context where it will
  57.    be used to recognize, rather than just generate an insn. 
  58.  
  59.    NON_PC_SET_SRC will be non-zero if this pattern was seen in a SET_SRC
  60.    of a SET whose destination is not (pc).  */
  61.  
  62. static void
  63. walk_insn_part (part, recog_p, non_pc_set_src)
  64.      rtx part;
  65.      int recog_p;
  66.      int non_pc_set_src;
  67. {
  68.   register int i, j;
  69.   register RTX_CODE code;
  70.   register char *format_ptr;
  71.  
  72.   if (part == 0)
  73.     return;
  74.  
  75.   code = GET_CODE (part);
  76.   switch (code)
  77.     {
  78.     case CLOBBER:
  79.       clobbers_seen_this_insn++;
  80.       break;
  81.  
  82.     case MATCH_OPERAND:
  83.       if (XINT (part, 0) > max_recog_operands)
  84.     max_recog_operands = XINT (part, 0);
  85.       if (XSTR (part, 2) && *XSTR (part, 2))
  86.     register_constraint_flag = 1;
  87.       return;
  88.  
  89.     case MATCH_OP_DUP:
  90.     case MATCH_PAR_DUP:
  91.       ++dup_operands_seen_this_insn;
  92.     case MATCH_SCRATCH:
  93.     case MATCH_PARALLEL:
  94.     case MATCH_OPERATOR:
  95.       if (XINT (part, 0) > max_recog_operands)
  96.     max_recog_operands = XINT (part, 0);
  97.       /* Now scan the rtl's in the vector inside the MATCH_OPERATOR or
  98.      MATCH_PARALLEL.  */
  99.       break;
  100.  
  101.     case LABEL_REF:
  102.       if (GET_CODE (XEXP (part, 0)) == MATCH_OPERAND)
  103.     break;
  104.       return;
  105.  
  106.     case MATCH_DUP:
  107.       ++dup_operands_seen_this_insn;
  108.       if (XINT (part, 0) > max_recog_operands)
  109.     max_recog_operands = XINT (part, 0);
  110.       return;
  111.  
  112.     case CC0:
  113.       if (recog_p)
  114.     have_cc0_flag = 1;
  115.       return;
  116.  
  117.     case LO_SUM:
  118.       if (recog_p)
  119.     have_lo_sum_flag = 1;
  120.       return;
  121.  
  122.     case SET:
  123.       walk_insn_part (SET_DEST (part), 0, recog_p);
  124.       walk_insn_part (SET_SRC (part), recog_p,
  125.               GET_CODE (SET_DEST (part)) != PC);
  126.       return;
  127.  
  128.     case IF_THEN_ELSE:
  129.       /* Only consider this machine as having a conditional move if the
  130.      two arms of the IF_THEN_ELSE are both MATCH_OPERAND.  Otherwise,
  131.      we have some specific IF_THEN_ELSE construct (like the doz
  132.      instruction on the RS/6000) that can't be used in the general
  133.      context we want it for.  */
  134.  
  135.       if (recog_p && non_pc_set_src
  136.       && GET_CODE (XEXP (part, 1)) == MATCH_OPERAND
  137.       && GET_CODE (XEXP (part, 2)) == MATCH_OPERAND)
  138.     have_cmove_flag = 1;
  139.       break;
  140.  
  141.     case REG: case CONST_INT: case SYMBOL_REF:
  142.     case PC:
  143.       return;
  144.     }
  145.  
  146.   format_ptr = GET_RTX_FORMAT (GET_CODE (part));
  147.  
  148.   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
  149.     switch (*format_ptr++)
  150.       {
  151.       case 'e':
  152.       case 'u':
  153.     walk_insn_part (XEXP (part, i), recog_p, non_pc_set_src);
  154.     break;
  155.       case 'E':
  156.     if (XVEC (part, i) != NULL)
  157.       for (j = 0; j < XVECLEN (part, i); j++)
  158.         walk_insn_part (XVECEXP (part, i, j), recog_p, non_pc_set_src);
  159.     break;
  160.       }
  161. }
  162.  
  163. static void
  164. gen_insn (insn)
  165.      rtx insn;
  166. {
  167.   int i;
  168.  
  169.   /* Walk the insn pattern to gather the #define's status.  */
  170.   clobbers_seen_this_insn = 0;
  171.   dup_operands_seen_this_insn = 0;
  172.   if (XVEC (insn, 1) != 0)
  173.     for (i = 0; i < XVECLEN (insn, 1); i++)
  174.       walk_insn_part (XVECEXP (insn, 1, i), 1, 0);
  175.  
  176.   if (clobbers_seen_this_insn > max_clobbers_per_insn)
  177.     max_clobbers_per_insn = clobbers_seen_this_insn;
  178.   if (dup_operands_seen_this_insn > max_dup_operands)
  179.     max_dup_operands = dup_operands_seen_this_insn;
  180. }
  181.  
  182. /* Similar but scan a define_expand.  */
  183.  
  184. static void
  185. gen_expand (insn)
  186.      rtx insn;
  187. {
  188.   int i;
  189.  
  190.   /* Walk the insn pattern to gather the #define's status.  */
  191.  
  192.   /* Note that we don't bother recording the number of MATCH_DUPs
  193.      that occur in a gen_expand, because only reload cares about that.  */
  194.   if (XVEC (insn, 1) != 0)
  195.     for (i = 0; i < XVECLEN (insn, 1); i++)
  196.       {
  197.     /* Compute the maximum SETs and CLOBBERS
  198.        in any one of the sub-insns;
  199.        don't sum across all of them.  */
  200.     clobbers_seen_this_insn = 0;
  201.  
  202.     walk_insn_part (XVECEXP (insn, 1, i), 0, 0);
  203.  
  204.     if (clobbers_seen_this_insn > max_clobbers_per_insn)
  205.       max_clobbers_per_insn = clobbers_seen_this_insn;
  206.       }
  207. }
  208.  
  209. /* Similar but scan a define_split.  */
  210.  
  211. static void
  212. gen_split (split)
  213.      rtx split;
  214. {
  215.   int i;
  216.  
  217.   /* Look through the patterns that are matched
  218.      to compute the maximum operand number.  */
  219.   for (i = 0; i < XVECLEN (split, 0); i++)
  220.     walk_insn_part (XVECEXP (split, 0, i), 1, 0);
  221.   /* Look at the number of insns this insn could split into.  */
  222.   if (XVECLEN (split, 2) > max_insns_per_split)
  223.     max_insns_per_split = XVECLEN (split, 2);
  224. }
  225.  
  226. static void
  227. gen_peephole (peep)
  228.      rtx peep;
  229. {
  230.   int i;
  231.  
  232.   /* Look through the patterns that are matched
  233.      to compute the maximum operand number.  */
  234.   for (i = 0; i < XVECLEN (peep, 0); i++)
  235.     walk_insn_part (XVECEXP (peep, 0, i), 1, 0);
  236. }
  237.  
  238. char *
  239. xmalloc (size)
  240.      unsigned size;
  241. {
  242.   register char *val = (char *) malloc (size);
  243.  
  244.   if (val == 0)
  245.     fatal ("virtual memory exhausted");
  246.  
  247.   return val;
  248. }
  249.  
  250. char *
  251. xrealloc (ptr, size)
  252.      char *ptr;
  253.      unsigned size;
  254. {
  255.   char *result = (char *) realloc (ptr, size);
  256.   if (!result)
  257.     fatal ("virtual memory exhausted");
  258.   return result;
  259. }
  260.  
  261. static void
  262. fatal (s, a1, a2)
  263.      char *s;
  264. {
  265.   fprintf (stderr, "genconfig: ");
  266.   fprintf (stderr, s, a1, a2);
  267.   fprintf (stderr, "\n");
  268.   exit (FATAL_EXIT_CODE);
  269. }
  270.  
  271. /* More 'friendly' abort that prints the line and file.
  272.    config.h can #define abort fancy_abort if you like that sort of thing.  */
  273.  
  274. void
  275. fancy_abort ()
  276. {
  277.   fatal ("Internal gcc abort.");
  278. }
  279.  
  280. int
  281. main (argc, argv)
  282.      int argc;
  283.      char **argv;
  284. {
  285.   rtx desc;
  286.   FILE *infile;
  287.   register int c;
  288.  
  289.   obstack_init (rtl_obstack);
  290.  
  291.   if (argc <= 1)
  292.     fatal ("No input file name.");
  293.  
  294.   infile = fopen (argv[1], "r");
  295.   if (infile == 0)
  296.     {
  297.       perror (argv[1]);
  298.       exit (FATAL_EXIT_CODE);
  299.     }
  300.  
  301.   init_rtl ();
  302.  
  303.   printf ("/* Generated automatically by the program `genconfig'\n\
  304. from the machine description file `md'.  */\n\n");
  305.  
  306.   /* Allow at least 10 operands for the sake of asm constructs.  */
  307.   max_recog_operands = 9;  /* We will add 1 later.  */
  308.   max_dup_operands = 1;
  309.  
  310.   /* Read the machine description.  */
  311.  
  312.   while (1)
  313.     {
  314.       c = read_skip_spaces (infile);
  315.       if (c == EOF)
  316.     break;
  317.       ungetc (c, infile);
  318.  
  319.       desc = read_rtx (infile);
  320.       if (GET_CODE (desc) == DEFINE_INSN)
  321.     gen_insn (desc);
  322.       if (GET_CODE (desc) == DEFINE_EXPAND)
  323.     gen_expand (desc);
  324.       if (GET_CODE (desc) == DEFINE_SPLIT)
  325.     gen_split (desc);
  326.       if (GET_CODE (desc) == DEFINE_PEEPHOLE)
  327.     gen_peephole (desc);
  328.     }
  329.  
  330.   printf ("\n#define MAX_RECOG_OPERANDS %d\n", max_recog_operands + 1);
  331.  
  332.   printf ("\n#define MAX_DUP_OPERANDS %d\n", max_dup_operands);
  333.  
  334.   /* This is conditionally defined, in case the user writes code which emits
  335.      more splits than we can readily see (and knows s/he does it).  */
  336.   printf ("#ifndef MAX_INSNS_PER_SPLIT\n#define MAX_INSNS_PER_SPLIT %d\n#endif\n",
  337.       max_insns_per_split);
  338.  
  339.   if (register_constraint_flag)
  340.     printf ("#define REGISTER_CONSTRAINTS\n");
  341.  
  342.   if (have_cc0_flag)
  343.     printf ("#define HAVE_cc0\n");
  344.  
  345.   if (have_cmove_flag)
  346.     {
  347.       /* ??? The #ifndef/#endif is a hack for targets like sparc where
  348.          conditional moves don't exist for all versions of the
  349.      architecture.  This won't be needed after conditional move support
  350.      has been clean up.  */
  351.       printf ("#ifndef HAVE_conditional_move\n");
  352.       printf ("#define HAVE_conditional_move 1\n");
  353.       printf ("#endif\n");
  354.     }
  355.  
  356.   if (have_lo_sum_flag)
  357.     printf ("#define HAVE_lo_sum\n");
  358.  
  359.   fflush (stdout);
  360.   exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
  361.   /* NOTREACHED */
  362.   return 0;
  363. }
  364.